HPAVC

home *** CD-ROM | disk | FTP | other *** search

/ HPAVC / HPAVC CD-ROM.iso / pc / XLIBP202.ZIP / XBM2.ASM < prev next >

Wrap

Assembly Source File | 1994-12-08 | 89.3 KB | 2,865 lines

; *************************************************************************** ; ** XLibPas v2.0 ** ; ** for Borland Pascal 7.0 ** ; ** by ** ; ** Tristan Tarrant ** ; *************************************************************************** ; ** Credits : ** ; ** Michael Abrash - Concepts, Algorithms ** ; ** Themie Gouthas - Main code and implementation ** ; ** Matthew MacKenzie - Compiled Bitmaps, Circles, etc. ** ; ** Tore Bastiansen - Virtual VSync Handler ** ; *************************************************************************** .MODEL TPASCAL .386 LOCALS include xlib2.inc include xbm2.inc .CODE xpbmtobm proc far srcpbm:dword,destbm:dword push ds push di push si les di,[destbm] ; es:di -> destination bitmap lds si,[srcpbm] ; ds:si -> source planar bitmap lodsb ; load AL with source pbm pixel width per plane mov bl,al ; save in CL xor ah,ah ; convert to word shl ax,2 ; mult by 4 giving source image width cmp ax,255 ; if the result > 255 then we have exceeded ja @@WidthError ; the max width of linear bm. stosb ; write do destbm lodsb ; tranfer source pbm height in pixels to stosb ; destbm xor ah,ah ; convert to word mul bl ; AX = AX * BL ie. total no. pixels per plane mov dx,di ; save DI, the pointer to the destination bm mov bl,3 ; set plane loop counter (BL) @@PlaneLoop: mov cx,ax ; set CX to total number of pixels per plane @@PixelLoop: movsb ; transfer pixel add di,3 ; increment destination to compensate for plane loop @@PixelLoop inc dx ; increment original di for next pixel plane mov di,dx ; and restore di from incremented original dec bl ; decrement plane counter jns @@PlaneLoop ; loop if more planes left xor ax,ax jmp short @@Done @@WidthError: mov ax,1 @@Done: pop si pop di pop ds ret xpbmtobm endp xbmtopbm proc far srcbm:dword,destpbm:dword push ds push di push si les di,[destpbm] ; es:di -> destination planar bitmap lds si,[srcbm] ; ds:si -> source bitmap lodsb ; load AX with source bitmap width test al,03h ; Check that width is a multiple of 4 jnz @@WidthIncompatible shr al,2 ; divide by 4 giving width of plane stosb ; store destination planar bitmap width mov bl,al ; and copy to bl lodsb stosb ; Transfer source bitmap height to dest pbm xor ah,ah ; Conver height to word mul bl ; calculate the total no. of pixels / plane mov dx,si ; save source offset mov bl,3 @@PlaneLoop: mov cx,ax ; set CX to total number of pixels per plane @@PixelLoop: movsb ; transfer pixel add si,3 ; increment src offset to compensate for plane loop @@PixelLoop inc dx ; increment original si for next pixel plane mov si,dx ; and restore si from incremented original dec bl ; decrement plane counter jns @@PlaneLoop ; loop if more planes left xor ax,ax jmp short @@Done @@WidthIncompatible: mov ax,1 @@Done: pop si pop di pop ds ret xbmtopbm endp xcompilebitmap proc far logicalwidth:word,bitmap:dword,output:dword LOCAL bwidth,scanx,scany,outputx,outputy,column,setcolumn,inputsize:word push si push di push ds mov word ptr [scanx],0 mov word ptr [scany],0 mov word ptr [outputx],0 mov word ptr [outputy],0 mov word ptr [column],0 mov word ptr [setcolumn],0 lds si,[bitmap] ; 32-bit pointer to source bitmap les di,[output] ; 32-bit pointer to destination stream lodsb ; load width byte xor ah, ah ; convert to word mov [bwidth], ax ; save for future reference mov bl, al ; copy width byte to bl lodsb ; load height byte -- already a word since ah=0 mul bl ; mult height word by width byte mov [inputsize], ax; to get pixel total @@MainLoop: mov bx, [scanx] ; position in original bitmap add bx, [scany] mov al, [si+bx] ; get pixel or al, al ; skip empty pixels jnz @@NoAdvance jmp @@Advance @@NoAdvance: mov dx, [setcolumn] cmp dx, [column] je @@SameColumn @@ColumnLoop: Emitw ROLAL ; emit code to move to new column Emitw ADCSIIMMED Emitb 0 inc dx cmp dx, [column] jl @@ColumnLoop Emitb OUTAL ; emit code to set VGA mask for new column mov [setcolumn], dx @@SameColumn: mov dx, [outputy] ; calculate output position add dx, [outputx] sub dx, 128 add word ptr [scanx], 4 mov cx, [scanx] ; within four pixels of right edge? cmp cx, [bwidth] jge @@OnePixel inc word ptr [outputx] mov ah, [si+bx+4] ; get second pixel or ah, ah jnz @@TwoPixels @@OnePixel: cmp dx, 127 ; can we use shorter form? jg @@OnePixLarge cmp dx, -128 jl @@OnePixLarge Emitw SHORTSTORE8 Emitb dl ; 8-bit position in output jmp @@EmitOnePixel @@OnePixLarge: Emitw STORE8 Emitw dx ; position in output @@EmitOnePixel: Emitb al jmp short @@Advance @@TwoPixels: cmp dx, 127 jg @@TwoPixLarge cmp dx, -128 jl @@TwoPixLarge Emitw SHORTSTORE16 Emitb dl ; 8-bit position in output jmp @@EmitTwoPixels @@TwoPixLarge: Emitw STORE16 Emitw dx ; position in output @@EmitTwoPixels: Emitw ax @@Advance: inc word ptr [outputx] mov ax, [scanx] add ax, 4 cmp ax, [bwidth] jl @@AdvanceDone mov dx, [outputy] add dx, [logicalwidth] mov cx, [scany] add cx, [bwidth] cmp cx, [inputsize] jl @@NoNewColumn inc word ptr [column] mov cx, [column] cmp cx, 4 je @@Exit ; Column 4: there is no column 4. xor cx, cx ; scany and outputy are 0 again for mov dx, cx ; the new column @@NoNewColumn: mov [outputy], dx mov [scany], cx mov word ptr [outputx], 0 mov ax,[column] @@AdvanceDone: mov [scanx], ax jmp @@MainLoop @@Exit: Emitb RETURN mov ax,di sub ax,word ptr [output] ; size of generated code pop ds pop di pop si ret xcompilebitmap endp xsizeofcbitmap proc far logicalwidth:word,bitmap:dword LOCAL bwidth,scanx,scany,outputx,outputy,column,setcolumn,inputsize:word push si push di push ds mov word ptr [scanx], 0 mov word ptr [scany], 0 mov word ptr [outputx], 0 mov word ptr [outputy], 0 mov word ptr [column], 0 mov word ptr [setcolumn], 0 lds si,[bitmap] ; 32-bit pointer to source bitmap mov di, 1 ; initial size is just the size of the far RET lodsb ; load width byte xor ah, ah ; convert to word mov [bwidth], ax ; save for future reference mov bl, al ; copy width byte to bl lodsb ; load height byte -- already a word since ah=0 mul bl ; mult height word by width byte mov [inputsize], ax; to get pixel total @@MainLoop: mov bx, [scanx] ; position in original bitmap add bx, [scany] mov al, [si+bx] ; get pixel or al, al ; skip empty pixels jnz @@NoAdvance jmp @@Advance @@NoAdvance: mov dx, [setcolumn] cmp dx, [column] je @@SameColumn @@ColumnLoop: add di, 5 ; size of code to move to new column inc dx cmp dx,[column] jl @@ColumnLoop inc di ; size of code to set VGA mask mov [setcolumn], dx @@SameColumn: mov dx, [outputy] ; calculate output position add dx, [outputx] sub dx, 128 add word ptr [scanx], 4 mov cx, [scanx] ; within four pixels of right edge? cmp cx, [bwidth] jge @@OnePixel inc word ptr [outputx] mov ah,[si+bx+4] ; get second pixel or ah, ah jnz @@TwoPixels @@OnePixel: cmp dx, 127 ; can we use shorter form? jg @@OnePixLarge cmp dx, -128 jl @@OnePixLarge add di, 4 ; size of 8-bit position in output plus one pixel jmp @@EmitOnePixel @@OnePixLarge: add di, 5 ; size of position in output plus one pixels @@EmitOnePixel: jmp short @@Advance @@TwoPixels: cmp dx, 127 jg @@TwoPixLarge cmp dx, -128 jl @@TwoPixLarge add di, 5 ; size of 8-bit position in output plus two pixels jmp @@EmitTwoPixels @@TwoPixLarge: add di, 6 ; size of 16-bit position in output plus two pixels @@EmitTwoPixels: @@Advance: inc word ptr [outputx] mov ax, [scanx] add ax,4 cmp ax, [bwidth] jl @@AdvanceDone mov dx, [outputy] add dx, [logicalwidth] mov cx, [scany] add cx, [bwidth] cmp cx, [inputsize] jl @@NoNewColumn inc word ptr [column] mov cx, [column] cmp cx, 4 je @@Exit ; Column 4: there is no column 4. xor cx,cx ; scany and outputy are 0 again for mov dx,cx ; the new column @@NoNewColumn: mov [outputy], dx mov [scany], cx mov word ptr [outputx], 0 mov ax,[column] @@AdvanceDone: mov [scanx], ax jmp @@MainLoop @@Exit: mov ax, di ; size of generated code pop ds pop di pop si ret xsizeofcbitmap endp xputcbitmap proc far XPos:word,YPos:word,PageOffset:word,Sprite:dword push ds mov cx, [SelectorInc] mov ax, [ScrnLogicalByteWidth] ; global Xlib variable mul word ptr [YPos] ; height in bytes mov si, [XPos] mov bx, si sar si, 2 ; width in bytes add si, ax add si, [PageOffset]; (YPos * screen width) + add si, 128 ; (Xpos / 4) + page base + 128 ==> starting pos and bx, 3 mov ah, ColumnMask[bx] mov dx, SCINDEX mov al, MAPMASK out dx, ax inc dx ; ready to send out other masks as bytes mov al, ah mov bx, SCREENSEG mov ds, bx ; We do this so the compiled shape won't need ; segment overrides. call dword ptr [Sprite] ; the business end of the routine pop ds ret xputcbitmap endp xcompilepbm proc far logicalwidth:word,bitmap:dword,output:dword LOCAL bwidth,scanx,scany,outputx,outputy,column,setcolumn,inputsize:word push si push di push ds mov word ptr [scanx],0 mov word ptr [scany],0 mov word ptr [outputx],0 mov word ptr [outputy],0 mov word ptr [column],0 mov word ptr [setcolumn],0 lds si,[bitmap] ; 32-bit pointer to source bitmap les di,[output] ; 32-bit pointer to destination stream lodsb ; load width byte xor ah, ah ; convert to word mov [bwidth], ax ; save for future reference mov bl, al ; copy width byte to bl lodsb ; load height byte -- already a word since ah=0 mul bl ; mult height word by width byte mov [inputsize], ax; to get pixel total @@MainLoop: mov bx, [scanx] ; position in original bitmap add bx, [scany] mov al, [si+bx] ; get pixel or al, al ; skip empty pixels jnz @@NoAdvance jmp @@Advance @@NoAdvance: mov dx, [setcolumn] cmp dx, [column] je @@SameColumn @@ColumnLoop: Emitw ROLAL ; emit code to move to new column Emitw ADCSIIMMED Emitb 0 inc dx cmp dx, [column] jl @@ColumnLoop Emitb OUTAL ; emit code to set VGA mask for new column mov [setcolumn], dx @@SameColumn: mov dx, [outputy] ; calculate output position add dx, [outputx] sub dx, 128 inc word ptr [scanx] mov cx, [scanx] ; within four pixels of right edge? cmp cx, [bwidth] jge @@OnePixel inc word ptr [outputx] mov ah, [si+bx+1] ; get second pixel or ah, ah jnz @@TwoPixels @@OnePixel: cmp dx, 127 ; can we use shorter form? jg @@OnePixLarge cmp dx, -128 jl @@OnePixLarge Emitw SHORTSTORE8 Emitb dl ; 8-bit position in output jmp @@EmitOnePixel @@OnePixLarge: Emitw STORE8 Emitw dx ; position in output @@EmitOnePixel: Emitb al jmp short @@Advance @@TwoPixels: cmp dx, 127 jg @@TwoPixLarge cmp dx, -128 jl @@TwoPixLarge Emitw SHORTSTORE16 Emitb dl ; 8-bit position in output jmp @@EmitTwoPixels @@TwoPixLarge: Emitw STORE16 Emitw dx ; position in output @@EmitTwoPixels: Emitw ax @@Advance: inc word ptr [outputx] mov ax, [scanx] inc ax cmp ax, [bwidth] jl @@AdvanceDone mov dx, [outputy] add dx, [logicalwidth] mov cx, [scany] add cx, [bwidth] cmp cx, [inputsize] jl @@NoNewColumn inc word ptr [column] mov cx, [column] cmp cx, 4 je @@Exit ; Column 4: there is no column 4. xor cx, cx ; scany and outputy are 0 again for mov dx, cx ; the new column add si, [inputsize] @@NoNewColumn: mov [outputy], dx mov [scany], cx xor ax, ax mov word ptr [outputx], 0 @@AdvanceDone: mov [scanx], ax jmp @@MainLoop @@Exit: Emitb RETURN mov ax,di sub ax,word ptr [output] ; size of generated code pop ds pop di pop si ret xcompilepbm endp xsizeofcpbm proc far logicalwidth:word,bitmap:dword LOCAL bwidth,scanx,scany,outputx,outputy,column,setcolumn,inputsize:word push si push di push ds mov word ptr [scanx], 0 mov word ptr [scany], 0 mov word ptr [outputx], 0 mov word ptr [outputy], 0 mov word ptr [column], 0 mov word ptr [setcolumn], 0 lds si,[bitmap] ; 32-bit pointer to source bitmap mov di, 1 ; initial size is just the size of the far RET lodsb ; load width byte xor ah, ah ; convert to word mov [bwidth], ax ; save for future reference mov bl, al ; copy width byte to bl lodsb ; load height byte -- already a word since ah=0 mul bl ; mult height word by width byte mov [inputsize], ax; to get pixel total @@MainLoop: mov bx, [scanx] ; position in original bitmap add bx, [scany] mov al, [si+bx] ; get pixel or al, al ; skip empty pixels jnz @@NoAdvance jmp @@Advance @@NoAdvance: mov dx, [setcolumn] cmp dx, [column] je @@SameColumn @@ColumnLoop: add di, 5 ; size of code to move to new column inc dx cmp dx,[column] jl @@ColumnLoop inc di ; size of code to set VGA mask mov [setcolumn], dx @@SameColumn: mov dx, [outputy] ; calculate output position add dx, [outputx] sub dx, 128 inc word ptr [scanx] mov cx, [scanx] ; within four pixels of right edge? cmp cx, [bwidth] jge @@OnePixel inc word ptr [outputx] mov ah,[si+bx+1] ; get second pixel or ah, ah jnz @@TwoPixels @@OnePixel: cmp dx, 127 ; can we use shorter form? jg @@OnePixLarge cmp dx, -128 jl @@OnePixLarge add di, 4 ; size of 8-bit position in output plus one pixel jmp @@EmitOnePixel @@OnePixLarge: add di, 5 ; size of position in output plus one pixels @@EmitOnePixel: jmp short @@Advance @@TwoPixels: cmp dx, 127 jg @@TwoPixLarge cmp dx, -128 jl @@TwoPixLarge add di, 5 ; size of 8-bit position in output plus two pixels jmp @@EmitTwoPixels @@TwoPixLarge: add di, 6 ; size of 16-bit position in output plus two pixels @@EmitTwoPixels: @@Advance: inc word ptr [outputx] mov ax, [scanx] inc ax cmp ax, [bwidth] jl @@AdvanceDone mov dx, [outputy] add dx, [logicalwidth] mov cx, [scany] add cx, [bwidth] cmp cx, [inputsize] jl @@NoNewColumn inc word ptr [column] mov cx, [column] cmp cx, 4 je @@Exit ; Column 4: there is no column 4. xor cx,cx ; scany and outputy are 0 again for mov dx,cx ; the new column add si, [inputsize] @@NoNewColumn: mov [outputy], dx mov [scany], cx xor ax, ax mov word ptr [outputx], ax @@AdvanceDone: mov [scanx], ax jmp @@MainLoop @@Exit: mov ax, di ; size of generated code pop ds pop di pop si ret xsizeofcpbm endp xflipmaskedpbm proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword,Orientation:word LOCAL Plane:byte,BMHeight:byte,LineInc:word push si push di push ds cld mov ax,SCREENSEG mov es,ax mov ax,[Y] ; Calculate dest screen row mov bx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul bx ; width then adding screen offset mov di,[ScrnOffs] ; store result in DI add di,ax mov cx,[X] ; Load X coord into CX and make a mov dx,cx ; copy in DX shr dx,2 ; Find starting byte in dest row add di,dx ; add to DI giving screen offset of ; first pixel's byte lds si,[Bitmap] ; DS:SI -> Bitmap data lodsw ; Al = B.M. width (bytes) AH = B.M. ; height cmp Orientation,0 jz UnFlippedMasked mov [BMHeight],ah ; Save source bitmap dimensions xor ah,ah ; LineInc = bytes to the begin. add bx,ax ; of bitmaps next row on screen mov [LineInc],bx mov bh,al ; Use bh as column loop count and cx,0003h ; mask X coord giving plane of 1st ; bitmap pixel(zero CH coincidentally) mov ah,11h ; Init. mask for VGA plane selection shl ah,cl ; Shift for starting pixel plane mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 @@PlaneLoop: push di ; Save bitmap's start dest. offset mov bl,[BMHeight] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl @@ColLoop: lodsb ; Get next source bitmap byte or al,al ; If not zero then write to dest. jz @@NoPixel ; otherwise skip to next byte mov es:[di],al @@NoPixel: dec di loop @@ColLoop ; loop if more columns left add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop di ; Restore bitmaps start dest byte ror ah,1 ; Shift mask for next plane sbb di,0 ; If wrapped increment dest address dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left pop ds ; restore data segment pop di ; restore registers pop si ret xflipmaskedpbm endp xputmaskedpbm proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,BMHeight:byte,LineInc:word push si push di push ds cld mov ax,SCREENSEG mov es,ax mov ax,Y ; Calculate dest screen row mov bx,ScrnLogicalByteWidth ; by mult. dest Y coord by Screen mul bx ; width then adding screen offset mov di,[ScrnOffs] ; store result in DI add di,ax mov cx,[X] ; Load X coord into CX and make a mov dx,cx ; copy in DX shr dx,2 ; Find starting byte in dest row add di,dx ; add to DI giving screen offset of ; first pixel's byte lds si,[Bitmap] ; DS:SI -> Bitmap data lodsw ; Al = B.M. width (bytes) AH = B.M. ; height UnFlippedMasked: mov [BMHeight],ah ; Save source bitmap dimensions xor ah,ah ; LineInc = bytes to the begin. sub bx,ax ; of bitmaps next row on screen mov [LineInc],bx mov bh,al ; Use bh as column loop count and cx,0003h ; mask X coord giving plane of 1st ; bitmap pixel(zero CH coincidentally) mov ah,11h ; Init. mask for VGA plane selection shl ah,cl ; Shift for starting pixel plane mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 @@PlaneLoop: push di ; Save bitmap's start dest. offset mov bl,[BMHeight] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl @@ColLoop: lodsb ; Get next source bitmap byte or al,al ; If not zero then write to dest. jz @@NoPixel ; otherwise skip to next byte mov es:[di],al @@NoPixel: inc di loop @@ColLoop ; loop if more columns left add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane adc di,0 ; If wrapped increment dest address dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedpbm endp xputpbm proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,BMHeight:byte,LineInc:word push si push di push ds cld mov ax,SCREENSEG mov es,ax mov ax,[Y] ; Calculate dest screen row mov bx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul bx ; width then adding screen offset mov di,[ScrnOffs] ; store result in DI add di,ax mov cx,[X] ; Load X coord into CX and make a mov dx,cx ; copy in DX shr dx,2 ; Find starting byte in dest row add di,dx ; add to DI giving screen offset of ; first pixel's byte lds si,[Bitmap] ; DS:SI -> Bitmap data lodsw ; Al = B.M. width (bytes) AH = B.M. ; height UnFlipped: mov [BMHeight],ah ; Save source bitmap dimensions xor ah,ah ; LineInc = bytes to the begin. sub bx,ax ; of bitmaps next row on screen mov [LineInc],bx mov bh,al ; Self Modifying, Shame, shame shame.. and cx,0003h ; mask X coord giving plane of 1st ; bitmap pixel(zero CH coincidentally) mov ah,11h ; Init. mask for VGA plane selection shl ah,cl ; Shift for starting pixel plane mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 @@PlaneLoop: push di mov bl,[BMHeight] mov al,ah out dx,al @@RowLoop: mov cl,bh shr cl,1 rep movsw ; Copy a complete row for curr plane adc cl,0 rep movsb add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane adc di,0 ; If wrapped increment dest address dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left pop ds ; restore data segment pop di ; restore registers pop si ret xputpbm endp xflippbm proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword,Orientation:word LOCAL Plane:byte,BMHeight:byte,LineInc:word push si push di push ds cld mov ax,SCREENSEG mov es,ax mov ax,[Y] ; Calculate dest screen row mov bx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul bx ; width then adding screen offset mov di,[ScrnOffs] ; store result in DI add di,ax mov cx,[X] ; Load X coord into CX and make a mov dx,cx ; copy in DX shr dx,2 ; Find starting byte in dest row add di,dx ; add to DI giving screen offset of ; first pixel's byte lds si,[Bitmap] ; DS:SI -> Bitmap data lodsw ; Al = B.M. width (bytes) AH = B.M. ; height cmp Orientation,0 jz UnFlipped mov [BMHeight],ah ; Save source bitmap dimensions xor ah,ah ; LineInc = bytes to the begin. add bx,ax ; of bitmaps next row on screen mov [LineInc],bx mov bh,al ; Use bh as column loop count and cx,0003h ; mask X coord giving plane of 1st ; bitmap pixel(zero CH coincidentally) mov ah,11h ; Init. mask for VGA plane selection shl ah,cl ; Shift for starting pixel plane mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 @@PlaneLoop: push di ; Save bitmap's start dest. offset mov bl,[BMHeight] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl @@ColLoop: lodsb mov es:[di],al dec di sub di,2 loop @@ColLoop ; loop if more columns left @@DoneCol: add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop di ; Restore bitmaps start dest byte ror ah,1 ; Shift mask for next plane sbb di,0 ; If wrapped increment dest address dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left pop ds ; restore data segment pop di ; restore registers pop si ret xflippbm endp xgetpbm proc far X:word,Y:word,SrcWidth:byte,SrcHeight:byte,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,LineInc:word push si push di push ds cld mov ax,[Y] ; Calculate screen row mov bx,[ScrnLogicalByteWidth] ; by mult. Y coord by Screen mul bx ; width then adding screen offset mov si,[ScrnOffs] ; store result in SI add si,ax mov cx,[X] ; Load X coord into CX and make a mov dx,cx ; copy in DX shr dx,2 ; Find starting byte in screen row add si,dx ; add to SI giving screen offset of ; first pixel's byte mov ax,SCREENSEG mov ds,ax les di,[Bitmap] ; ES:DI -> Bitmap data mov al,[SrcWidth] mov ah,[SrcHeight] stosw ; Al = B.M. width (bytes) AH = B.M. ; height xor ah,ah ; LineInc = bytes to the begin. sub bx,ax ; of bitmaps next row on screen mov [LineInc],bx mov bh,al ; Self Modifying, Shame, shame shame.. and cx,0003h ; mask X coord giving plane of 1st ; bitmap pixel(zero CH coincidentally) mov ah,11h ; Init. mask for VGA plane selection shl ah,cl ; Shift for starting pixel plane mov dx,GCINDEX ; Prepare VGA for cpu to video reads mov al,READMAP out dx,al inc dx mov [Plane],4 ; Set plane counter (BH) to 4 mov al,cl @@PlaneLoop: push si mov bl,[SrcHeight] out dx,al @@RowLoop: mov cl,bh shr cl,1 rep movsw ; Copy a complete row for curr plane adc cl,0 rep movsb add si,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop si ; Restore bitmaps start dest byte inc al ; Select next plane to read from and al,3 ; rol ah,1 ; Shift mask for next plane adc si,0 ; If wrapped increment dest address dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left pop ds ; restore data segment pop di ; restore registers pop si ret xgetpbm endp xputmaskedpbmclipx proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,CType,LeftSkip,DataInc,AWidth,Height,TopRow,LineInc:word push si push di push ds cld les si,[Bitmap] ; Point ES:SI to start of bitmap xor ax,ax ; Clear AX mov [CType],ax ; Clear Clip type descision var mov al,byte ptr es:[si] ; AX=width (byte coverted to word) mov di,[X] ; DI = X coordinate of dest mov cx,di ; copy to CX sar di,2 ; convert to offset in row mov dx,[LeftClip] ; Is X Coord to the right of sub dx,di ; LeftClip ? jle @@NotLeftClip ; Yes! => no left clipping cmp dx,ax ; Is dist of X Coord from jnl @@NotVisible ; ClipLeft > Width ? yes => the ; bitmap is not visible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub ax,dx mov [CType],1 jmp short @@HorizClipDone @@NotVisible: mov ax,1 pop ds ; restore data segment pop di pop si ret @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,ax jge @@HorizClipDone inc dx sub ax,dx mov [DataInc],ax mov ax,dx mov [CType],-1 @@HorizClipDone: xor bh,bh mov bl,byte ptr es:[si+1] mov [AWidth],ax mov [Height],bx add si,2 add si,[LeftSkip] mov bx,[ScrnLogicalByteWidth] mov dx,bx sub dx,ax mov [LineInc],dx mov ax,[Y] mul bx add di,ax add di,[ScrnOffs] mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx and cx,3 mov ah,11h shl ah,cl mov dx,SCINDEX mov al,MAPMASK out dx,al inc dx mov [Plane],4 mov bh,byte ptr [AWidth] @@PlaneLoop: push di mov bl,byte ptr [Height] mov al,ah out dx,al @@RowLoop: mov cl,bh jcxz @@NoWidth @@ColLoop: lodsb or al,al jz @@NoPixel mov es:[di],al @@NoPixel: inc di loop @@ColLoop @@NoWidth: add si,[DataInc] add di,[LineInc] dec bl jnz @@RowLoop pop di rol ah,1 jnb @@Nocarry ; Jump if not plane transition mov bl,ah ; Save Plane Mask mov ax,[CType] ; set AX to clip type inc variable add bh,al ; Update advancing variables sub [DataInc],ax ; sub [LineInc],ax ; cmp al,0 ; What type of clip do we have mov ah,bl ; restore Plane mask jg @@RightAdvance ; jump on a right clip! inc di ; otherwise increment DI jmp @@Nocarry @@RightAdvance: dec si @@Nocarry: dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedpbmclipx endp xputmaskedpbmclipy proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL AWidth,Height,TopRow,LineInc,PlaneInc:word push si push di push ds cld les si,[Bitmap] xor bh,bh mov bl,byte ptr es:[si+1] ; BX = height xor ah,ah mov al,byte ptr es:[si] ; AX = width mov cx,ax ; Save AX mul bx ; AX = AX*BX = bytes/plane mov [PlaneInc],ax ; save as PlaneInc mov ax,cx ; Restore AX mov di,[X] mov cx,di shr di,2 ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,bx jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub bx,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED P.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,bx jg @@VertClipDone inc dx mov bx,dx @@VertClipDone: mov [AWidth],ax mov [Height],bx ; Calculate relative offset in data mul [TopRow] ; of first visible scanline add ax,2 ; Skip dimension bytes in source add si,ax ; Skip top rows that arent visible mov ax,[Y] ; Calculate screen row mov bx,[ScrnLogicalByteWidth] ; by mult. Y coord by Screen mul bx ; width then adding screen offset add di,ax add di,[ScrnOffs] sub bx,[AWidth] ; calculate difference from end of mov [LineInc],bx ; b.m. in curr line to beginning of ; b.m. on next scan line mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx mov ah,11h ; Set up initial plane mask and cx,3 shl ah,cl mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov bh,4 ; Set plane counter to 4 @@PlaneLoop: push di ; Save bitmap's start dest. offset push si ; Save Bitmaps data offset mov bl,byte ptr [Height] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,byte ptr [AWidth] ; Reset Column counter cl @@ColLoop: lodsb ; Get next source bitmap byte or al,al ; If not zero then write to dest. jz @@NoPixel ; otherwise skip to next byte mov es:[di],al @@NoPixel: inc di loop @@ColLoop ; loop if more columns left add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop si ; Restore SI and set to offset of add si,[PlaneInc] ; first vis pixel in next plane data pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane adc di,0 ; if carry increment screen offset dec bh ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedpbmclipy endp xputmaskedpbmclipxy proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,CType,LeftSkip,DataInc,AWidth,Height,TopRow,LineInc,PlaneInc:word push si push di push ds cld les si,[Bitmap] xor ax,ax mov [CType],ax mov al,byte ptr es:[si] ; AX = width xor bh,bh mov bl,byte ptr es:[si+1] ; BX = height mov cx,ax ; Save AX mul bx ; AX = AX*BX = bytes/plane mov [PlaneInc],ax ; save as PlaneInc mov ax,cx ; Restore AX mov di,[X] ; DI = X coordinate of dest. mov cx,di ; save in CX sar di,2 ; convert to address byte ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,bx jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub bx,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED P.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,bx jg @@VertClipDone inc dx mov bx,dx @@VertClipDone: ;;;;; CLIP PROCESSING FOR LEFT CLIP BORDER ;;;;;;;;;;;;;;;;;;; mov dx,[LeftClip] sub dx,di jle @@NotLeftClip cmp dx,ax jnl @@NotVisible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub ax,dx mov [CType],1 jmp short @@HorizClipDone ;;;;; CLIP PROCESSING FOR RIGHT CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,ax jge @@HorizClipDone ; was jg inc dx sub ax,dx mov [DataInc],ax mov ax,dx mov [CType],-1 @@HorizClipDone: mov [AWidth],ax ; Save width and height of clipped mov [Height],bx ; image add ax,[DataInc] ; AX = original width of image mul [TopRow] ; Calculate bytes in clipped top add si,ax ; rows add si,2 ; Skip dimension bytes in source add si,[LeftSkip] ; Skip pixels in front of row that ; are clipped mov bx,[ScrnLogicalByteWidth] ; Set BX to Logical Screen Width mov dx,bx ; BX - Width of image = No. bytes sub dx,[AWidth] ; to first byte of next screen mov [LineInc],dx ; row. mov ax,[Y] ; Calculate screen start row mul bx ; then adding screen offset add di,ax add di,[ScrnOffs] mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx and cx,3 mov ah,11h ; Set up initial plane mask shl ah,cl mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 mov bh,byte ptr [AWidth] ; set bh to width for fast looping @@PlaneLoop: push di ; Save bitmap's start dest. offset push si mov bl,byte ptr [Height] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl jcxz @@NoWidth @@ColLoop: lodsb ; Get next source bitmap byte or al,al ; If not zero then write to dest. jz @@NoPixel ; otherwise skip to next byte mov es:[di],al @@NoPixel: inc di loop @@ColLoop @@NoWidth: add si,[DataInc] ; Move to next source row add di,[LineInc] ; Move to next screen row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop si ; Restore SI and set to offset of add si,[PlaneInc] ; first vis pixel in next plane data pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane ; Plane Transition (A HACK but it works!) jnb @@Nocarry ; Jump if not plane transition mov bl,ah ; Save Plane Mask mov ax,[CType] ; set AX to clip type inc variable add bh,al ; Update advancing variables sub [DataInc],ax ; sub [LineInc],ax ; cmp al,0 ; What type of clip do we have mov ah,bl ; restore Plane mask jg @@RightAdvance ; jump on a right clip! inc di ; otherwise increment DI jmp @@Nocarry @@RightAdvance: dec si @@Nocarry: dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedpbmclipxy endp xputpbmclipx proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,CType,LeftSkip,DataInc,AWidth,Height,TopRow,LineInc:word push si push di push ds cld les si,[Bitmap] xor ax,ax mov [CType],ax mov al,byte ptr es:[si] ; AX = width mov di,[X] ; DI = X coordinate of dest. mov cx,di ; save in CX sar di,2 ; convert to address byte ;;;;; CLIP PROCESSING FOR LEFT CLIP BORDER ;;;;;;;;;;;;;;;;;;; mov dx,[LeftClip] sub dx,di jle @@NotLeftClip cmp dx,ax jnl @@NotVisible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub ax,dx mov [CType],1 jmp short @@HorizClipDone ;;;; EXIT FOR COMPLETELY OBSCURED P.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR RIGHT CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,ax jge @@HorizClipDone ; was jg inc dx sub ax,dx mov [DataInc],ax mov ax,dx mov [CType],-1 @@HorizClipDone: xor bh,bh mov bl,byte ptr es:[si+1] ; BX = height mov [AWidth],ax ; Save width and height of clipped mov [Height],bx ; image add si,2 ; Skip dimension bytes in source add si,[LeftSkip] ; Skip pixels in front of row that ; are clipped mov bx,[ScrnLogicalByteWidth] ; Set BX to Logical Screen Width mov dx,bx ; BX - Width of image = No. bytes sub dx,ax ; to first byte of next screen mov [LineInc],dx ; row. mov ax,[Y] ; Calculate screen start row mul bx ; then adding screen offset add di,ax add di,[ScrnOffs] mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx and cx,3 mov ah,11h ; Set up initial plane mask shl ah,cl mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 mov bh,byte ptr [AWidth] ; set bh to width for fast looping @@PlaneLoop: push di ; Save bitmap's start dest. offset mov bl,byte ptr [Height] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl shr cl,1 rep movsw ; Copy a complete row adc cl,0 rep movsb add si,[DataInc] ; Move to next source row add di,[LineInc] ; Move to next screen row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane ; Plane Transition (A HACK but it works!) jnb @@Nocarry ; Jump if not plane transition mov bl,ah ; Save Plane Mask mov ax,[CType] ; set AX to clip type inc variable add bh,al ; Update advancing variables sub [DataInc],ax ; sub [LineInc],ax ; cmp al,0 ; What type of clip do we have mov ah,bl ; restore Plane mask jg @@RightAdvance ; jump on a right clip! inc di ; otherwise increment DI jmp @@Nocarry @@RightAdvance: dec si @@Nocarry: dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputpbmclipx endp xputpbmclipy proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL AWidth,Height,TopRow,LineInc,PlaneInc:word push si push di push ds cld les si,[Bitmap] xor bh,bh mov bl,byte ptr es:[si+1] ; BX = height ;mov [Height],bx xor ah,ah mov al,byte ptr es:[si] ; AX = width mov [AWidth],ax mov cx,ax ; Save AX mul bx ; AX = AX*BX = bytes/plane mov [PlaneInc],ax ; save as PlaneInc mov ax,cx ; Restore AX mov di,[X] mov cx,di and cx,3 shr di,2 ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,bx jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub bx,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED P.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,bx jg @@VertClipDone inc dx mov bx,dx @@VertClipDone: mov [Height],bx ; Calculate relative offset in data mul [TopRow] ; of first visible scanline add ax,2 ; Skip dimension bytes in source add si,ax ; Skip top rows that arent visible mov ax,[Y] ; Calculate screen row mov bx,[ScrnLogicalByteWidth] ; by mult. Y coord by Screen mul bx ; width then adding screen offset add di,ax add di,[ScrnOffs] sub bx,[AWidth] ; calculate difference from end of mov [LineInc],bx ; b.m. in curr line to beginning of ; b.m. on next scan line mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx mov ah,11h ; Set up initial plane mask shl ah,cl mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov bh,4 ; Set plane counter to 4 @@PlaneLoop: push di ; Save bitmap's start dest. offset push si ; Save Bitmaps data offset mov bl,byte ptr [Height] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,byte ptr [AWidth] ; Reset Column counter cl shr cl,1 rep movsw ; Copy a complete row adc cl,0 rep movsb add di,[LineInc] ; Move to next row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop si ; Restore SI and set to offset of add si,[PlaneInc] ; first vis pixel in next plane data pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane adc di,0 ; if carry increment screen offset dec bh ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputpbmclipy endp xputpbmclipxy proc far X:word,Y:word,ScrnOffs:word,Bitmap:dword LOCAL Plane:byte,CType,LeftSkip,DataInc,AWidth,Height,TopRow,LineInc,PlaneInc:word push si push di push ds cld les si,[Bitmap] xor ax,ax mov [CType],ax mov al,byte ptr es:[si] ; AX = width xor bh,bh mov bl,byte ptr es:[si+1] ; BX = height mov cx,ax ; Save AX mul bx ; AX = AX*BX = bytes/plane mov [PlaneInc],ax ; save as PlaneInc mov ax,cx ; Restore AX mov di,[X] ; DI = X coordinate of dest. mov cx,di ; save in CX sar di,2 ; convert to address byte ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,bx jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub bx,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED P.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,bx jg @@VertClipDone inc dx mov bx,dx @@VertClipDone: ;;;;; CLIP PROCESSING FOR LEFT CLIP BORDER ;;;;;;;;;;;;;;;;;;; mov dx,[LeftClip] sub dx,di jle @@NotLeftClip cmp dx,ax jnl @@NotVisible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub ax,dx mov [CType],1 jmp short @@HorizClipDone ;;;;; CLIP PROCESSING FOR RIGHT CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,ax jge @@HorizClipDone ; was jg inc dx sub ax,dx mov [DataInc],ax mov ax,dx mov [CType],-1 @@HorizClipDone: mov [AWidth],ax ; Save width and height of clipped mov [Height],bx ; image add ax,[DataInc] ; AX = original width of image mul [TopRow] ; Calculate bytes in clipped top add si,ax ; rows add si,2 ; Skip dimension bytes in source add si,[LeftSkip] ; Skip pixels in front of row that ; are clipped mov bx,[ScrnLogicalByteWidth] ; Set BX to Logical Screen Width mov dx,bx ; BX - Width of image = No. bytes sub dx,[AWidth] ; to first byte of next screen mov [LineInc],dx ; row. mov ax,[Y] ; Calculate screen start row mul bx ; then adding screen offset add di,ax add di,[ScrnOffs] mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx and cx,3 mov ah,11h ; Set up initial plane mask shl ah,cl mov dx,SCINDEX ; Prepare VGA for cpu to video writes mov al,MAPMASK out dx,al inc dx mov [Plane],4 ; Set plane counter to 4 mov bh,byte ptr [AWidth] ; set bh to width for fast looping @@PlaneLoop: push di ; Save bitmap's start dest. offset push si mov bl,byte ptr [Height] ; Reset row counter (BL) mov al,ah out dx,al ; set vga write plane @@RowLoop: mov cl,bh ; Reset Column counter cl shr cl,1 rep movsw ; Copy a complete row adc cl,0 rep movsb add si,[DataInc] ; Move to next source row add di,[LineInc] ; Move to next screen row dec bl ; decrement row counter jnz @@RowLoop ; Jump if more rows left pop si ; Restore SI and set to offset of add si,[PlaneInc] ; first vis pixel in next plane data pop di ; Restore bitmaps start dest byte rol ah,1 ; Shift mask for next plane ; Plane Transition (A HACK but it works!) jnb @@Nocarry ; Jump if not plane transition mov bl,ah ; Save Plane Mask mov ax,[CType] ; set AX to clip type inc variable add bh,al ; Update advancing variables sub [DataInc],ax ; sub [LineInc],ax ; cmp al,0 ; What type of clip do we have mov ah,bl ; restore Plane mask jg @@RightAdvance ; jump on a right clip! inc di ; otherwise increment DI jmp @@Nocarry @@RightAdvance: dec si @@Nocarry: dec [Plane] ; Decrement plane counter jnz @@PlaneLoop ; Jump if more planes left xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputpbmclipxy endp xstorevbmimage proc far VramOffs:word,AAlign:word,LBitmap:dword LOCAL BMWidth:byte push si push di push ds cld mov ax,SCREENSEG ; Point ES to screen segment mov es,ax mov di,[VramOffs] ; Point ES:DI to VRAM dest start mov bx,[AAlign] ; Set BL to first pixel plane align and bl,03h lds si,[LBitmap] ; DS:SI -> source linear Bitmap lodsw ; Al = B.M. width (bytes) AH = B.M. mov bh,ah ; Save source bitmap dimensions mov [BMWidth],al ; mov dx,SCINDEX ; Initialize Map Mask for plane mov al,MAPMASK ; selection out dx,al inc dx xor ch,ch ; clear CH @@RowLoop: mov cl,bl ; Set initial plane for current mov ah,11h ; allignment shl ah,cl mov cl,[BMWidth] ; Initialize column counter @@ColLoop: mov al,ah out dx,al ; set vga write plane lodsb ; load next LBM pixel mov es:[di],al ; store it in Video Ram shl ah,1 ; rotate plane mask jnb @@NoAddrIncr ; Time to increment dest address ? inc di ; Yes: increment addr and reset mov ah,11h ; plane mask to plane 0 @@NoAddrIncr: loop @@ColLoop ; Loop to next pixel column cmp ah,11h ; je @@skip inc di ; Increment dest addr ;@@skip: dec bh ; Decrement row counter jnz @@RowLoop ; Jump if more rows to go mov ax,di ; calculate video RAM consumed and sub ax,[VramOffs] ; return value pop ds ; restore data segment pop di ; restore registers pop si ret xstorevbmimage endp xputmaskedvbm proc far X:word,Y:word,ScrnOffs:word,SrcVBM:dword LOCAL VBMWidth:word,VBMHeight:word,NextLineIncr:word push si push di push ds cld mov ax,SCREENSEG ; Point es to VGA segment mov es,ax mov ax,[Y] ; Calculate dest screen row mov cx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul cx ; width then adding screen offset mov di,[ScrnOffs] ; store result in DI add di,ax mov si,[X] ; Load X coord into CX and make a mov bx,si ; copy in DX shr bx,2 ; Find starting byte in dest row add di,bx ; add to DI giving screen offset of ; first pixel's byte and si,3 ; get pixel alignment in si lds bx,[SrcVBM] ; DS:BX -> VBM data structure shl si,2 ; si = offset of data for curr ; alignment mov ax,word ptr [bx+ImageHeight] ; Get image height mov [VBMHeight],ax mov ax,word ptr [bx+ImageWidth] ; Get image width mov [VBMWidth],ax sub cx,ax ; NextLineIncr = bytes to the begin. mov [NextLineIncr],cx ; of bitmaps next row on screen mov dx,[bx+MaskPtr+AlignData+si] ; DS:SI -> mask data mov bx,[bx+ImagePtr+AlignData+si] ; ES:BX -> source video bitmap mov si,dx mov dx,GCINDEX ; Set bit mask for all bits from mov ax,BITMASK ; VGA latches and none from CPU out dx,ax mov dx,SCINDEX ; Point SC register to map mask mov al,MAPMASK ; in preperation for masking data out dx,al inc dx ; Point dx to SC data register mov ah,byte ptr [VBMHeight] ; AH = Scanline loop counter @@RowLoop: mov cx,[VBMWidth] ; Width in bytes across @@ColumnLoop: lodsb out dx,al mov al,es:[bx] ; load latches from source bitmap stosb ; store latches to dest. bitmap inc bx loop @@ColumnLoop add di,[NextLineIncr] ; point to start of next dest row dec ah ; decrement scan line counter jnz @@RowLoop ; jump if more scanlines left mov dx,GCINDEX+1 ; Restore bitmask to the default - mov al,0ffh ; all data from cpu out dx,al pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedvbm endp xputmaskedvbmclipx proc far X:word,Y:word,ScrnOffs:word,SrcVBM:dword LOCAL DataInc,LeftSkip,VBMWidth,VBMHeight,NextLineIncr:word push si push di push ds cld mov di,[X] ; load X coord int DI and make a mov si,di ; copy in SI sar di,2 ; Find Byte offset of X coord and si,3 ; Calculate pixels plane alignment shl si,2 ; Prepare to lookup mask & data les bx,[SrcVBM] ; ES:BX -> begining of VBM data mov cx,es:[bx+ImageWidth] ; Get image width and save in CX ;;;;; CLIP PROCESSING FOR LEFT CLIP BORDER ;;;;;;;;;;;;;;;;;;; mov dx,[LeftClip] sub dx,di jle @@NotLeftClip cmp dx,cx jnl @@NotVisible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub cx,dx jmp short @@HorizClipDone ;;;; EXIT FOR COMPLETELY OBSCURED V.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR RIGHT CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,cx jge @@HorizClipDone inc dx sub cx,dx mov [DataInc],cx mov cx,dx @@HorizClipDone: add di,[ScrnOffs] ; Add the current page offset mov [VBMWidth],cx mov ax,es:[bx+ImageHeight] ; Get image height and save in AX mov [VBMHeight],ax ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; mov ax,[Y] ; Calculate dest screen row mov cx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul cx ; width then adding screen offset add di,ax ; Add Dest Screen Row to di sub cx,[VBMWidth] mov [NextLineIncr],cx mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx mov ax,[bx+MaskPtr+AlignData+si] ; DS:SI -> mask data mov bx,[bx+ImagePtr+AlignData+si] ; ES:BX -> source video bitmap mov si,ax mov ax,[LeftSkip] ; Skip data/mask bytes in add bx,ax ; each row that have been clipped add si,ax ; by the L.H.S border mov dx,GCINDEX ; Set bit mask for all bits from mov ax,BITMASK ; VGA latches and none from CPU out dx,ax mov dx,SCINDEX ; Point SC register to map mask mov al,MAPMASK ; in preperation for masking data out dx,al inc dx ; Point dx to SC data register mov ah,byte ptr [VBMHeight] ; AH = Scanline loop counter @@RowLoop: mov cx,[VBMWidth] ; Width in bytes across @@ColumnLoop: lodsb out dx,al mov al,es:[bx] ; load latches from source bitmap stosb ; store latches to dest. bitmap inc bx loop @@ColumnLoop add bx,[DataInc] add si,[DataInc] add di,[NextLineIncr] ; point to start of next dest row dec byte ptr ah ; decrement scan line counter jnz @@RowLoop ; jump if more scanlines left mov dx,GCINDEX+1 ; Restore bitmask to the default - mov al,0ffh ; all data from cpu out dx,al xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedvbmclipx endp xputmaskedvbmclipy proc far X:word,Y:word,ScrnOffs:word,SrcVBM:dword LOCAL VBMWidth,VBMHeight,TopRow,NextLineIncr:word push si push di push ds cld mov di,[X] ; load X coord int DI and make a mov si,di ; copy in SI and si,3 ; Calculate pixels plane alignment shl si,2 ; Prepare to lookup mask & data les bx,[SrcVBM] ; ES:BX -> begining of VBM data mov ax,es:[bx+ImageHeight] ; Get image height and save in AX ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,ax jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub ax,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED V.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,ax jg @@VertClipDone inc dx mov ax,dx @@VertClipDone: shr di,2 ; Find Byte offset of X coord add di,[ScrnOffs] ; Add the current page offset mov cx,es:[bx+ImageWidth] ; Get image width and save in CX mov [VBMWidth],cx mov [VBMHeight],ax ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; mov ax,[Y] ; Calculate dest screen row mov cx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul cx ; width then adding screen offset add di,ax ; Add Dest Screen Row to di sub cx,[VBMWidth] mov [NextLineIncr],cx mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx mov ax,[bx+MaskPtr+AlignData+si] ; DS:SI -> mask data mov bx,[bx+ImagePtr+AlignData+si] ; ES:BX -> source video bitmap mov si,ax mov ax,[VBMWidth] ; Increment DS:BX and DS:SI to mul [TopRow] ; skip image/mask data that has add bx,ax ; been clipped by the top border add si,ax mov dx,GCINDEX ; Set bit mask for all bits from mov ax,BITMASK ; VGA latches and none from CPU out dx,ax mov dx,SCINDEX ; Point SC register to map mask mov al,MAPMASK ; in preperation for masking data out dx,al inc dx ; Point dx to SC data register mov ah,byte ptr [VBMHeight] ; AH = Scanline loop counter @@RowLoop: mov cx,[VBMWidth] ; Width in bytes across @@ColumnLoop: lodsb out dx,al mov al,es:[bx] ; load latches from source bitmap stosb ; store latches to dest. bitmap inc bx loop @@ColumnLoop add di,[NextLineIncr] ; point to start of next dest row dec byte ptr ah ; decrement scan line counter jnz @@RowLoop ; jump if more scanlines left mov dx,GCINDEX+1 ; Restore bitmask to the default - mov al,0ffh ; all data from cpu out dx,al xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedvbmclipy endp xputmaskedvbmclipxy proc far X:word,Y:word,ScrnOffs:word,SrcVBM:dword LOCAL DataInc,LeftSkip,VBMWidth,VBMHeight,TopRow,NextLineIncr:word push si push di push ds cld mov di,[X] ; load X coord int DI and make a mov si,di ; copy in SI sar di,2 ; Find Byte offset of X coord and si,3 ; Calculate pixels plane alignment shl si,2 ; Prepare to lookup mask & data les bx,[SrcVBM] ; ES:BX -> begining of VBM data mov cx,es:[bx+ImageWidth] ; Get image width and save in CX mov ax,es:[bx+ImageHeight] ; Get image height and save in AX ;;;;; CLIP PROCESSING FOR TOP CLIP BORDER ;;;;;;;;;;;;;;;;;;;;; mov dx,[TopClip] ; Compare u.l. Y coord with Top sub dx,[Y] ; clipping border jle @@NotTopClip ; jump if VBM not clipped from above cmp dx,ax jnl @@NotVisible ; jump if VBM is completely obscured mov [TopRow],dx sub ax,dx add [Y],dx jmp short @@VertClipDone ;;;; EXIT FOR COMPLETELY OBSCURED V.B.M's ;;;;;;;;;;;;;;;;;;;;;; @@NotVisible: mov ax,1 pop ds ; restore data segment pop di ; restore registers pop si ret ;;;;; CLIP PROCESSING FOR BOTTOM CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotTopClip: mov dx,[BottomClip] sub dx,[Y] js @@NotVisible mov [TopRow],0 cmp dx,ax jg @@VertClipDone inc dx mov ax,dx @@VertClipDone: ;;;;; CLIP PROCESSING FOR LEFT CLIP BORDER ;;;;;;;;;;;;;;;;;;; mov dx,[LeftClip] sub dx,di jle @@NotLeftClip cmp dx,cx jnl @@NotVisible add di,dx mov [LeftSkip],dx mov [DataInc],dx sub cx,dx jmp short @@HorizClipDone ;;;;; CLIP PROCESSING FOR RIGHT CLIP BORDER ;;;;;;;;;;;;;;;;;;; @@NotLeftClip: mov dx,[RightClip] sub dx,di js @@NotVisible mov [LeftSkip],0 mov [DataInc],0 cmp dx,cx jge @@HorizClipDone inc dx sub cx,dx mov [DataInc],cx mov cx,dx @@HorizClipDone: add di,[ScrnOffs] ; Add the current page offset mov [VBMWidth],cx mov [VBMHeight],ax ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; mov ax,[Y] ; Calculate dest screen row mov cx,[ScrnLogicalByteWidth] ; by mult. dest Y coord by Screen mul cx ; width then adding screen offset add di,ax ; Add Dest Screen Row to di sub cx,[VBMWidth] mov [NextLineIncr],cx mov ax,es ; copy ES to DS mov dx,SCREENSEG ; Point ES to VGA segment mov ds,ax mov es,dx mov ax,[bx+MaskPtr+AlignData+si] ; DS:SI -> mask data mov bx,[bx+ImagePtr+AlignData+si] ; ES:BX -> source video bitmap mov si,ax mov ax,[VBMWidth] ; Increment DS:BX and DS:SI to add ax,[DataInc] ; skip image/mask data that has mul [TopRow] ; been clipped by the top border add ax,[LeftSkip] ; Skip also data/mask bytes in add bx,ax ; each row that have been clipped add si,ax ; by the L.H.S border mov dx,GCINDEX ; Set bit mask for all bits from mov ax,BITMASK ; VGA latches and none from CPU out dx,ax mov dx,SCINDEX ; Point SC register to map mask mov al,MAPMASK ; in preperation for masking data out dx,al inc dx ; Point dx to SC data register mov ah,byte ptr [VBMHeight] ; AH = Scanline loop counter @@RowLoop: mov cx,[VBMWidth] ; Width in bytes across @@ColumnLoop: lodsb out dx,al mov al,es:[bx] ; load latches from source bitmap stosb ; store latches to dest. bitmap inc bx loop @@ColumnLoop add bx,[DataInc] add si,[DataInc] add di,[NextLineIncr] ; point to start of next dest row dec byte ptr ah ; decrement scan line counter jnz @@RowLoop ; jump if more scanlines left mov dx,GCINDEX+1 ; Restore bitmask to the default - mov al,0ffh ; all data from cpu out dx,al xor ax,ax pop ds ; restore data segment pop di ; restore registers pop si ret xputmaskedvbmclipxy endp xscale PROC FAR DestX:WORD, DestY:WORD, DestWidth:WORD, DestHeight:WORD,\ ScrnOffs : WORD, Bitmap:DWord LOCAL DecisionX:WORD, DecisionY:WORD, ClippedWidth:WORD, ClippedHeight:WORD,\ SourceWidth:WORD, SourceHeight:WORD, SourceOffset : Word,\ SourceWidth2 : Word, SourceHeight2 : word, ByteWidth : word,\ Plane : BYTE, DestWidth2 : word, DestHeight2 : word push ds push ds lds si, Bitmap xor ah, ah lodsb mov SourceWidth, ax lodsb mov SourceHeight, ax pop ds shl LeftClip, 2 shl RightClip, 2 cmp DestWidth, 2 ; If destination width is less than 2 jl @@Done ; then don't draw it. cmp DestHeight, 2 ; If destination height is less than 2 jl @@Done ; then don't draw it. mov ax, DestY ; If it is completely below the cmp ax, BottomClip ; lower clip bondry, jg @@Done ; then don't draw it. add ax, DestHeight ; If it is above clip boundries dec ax ; then don't draw it. cmp ax, TopClip jl @@Done mov ax, DestX ; If it is to the right of the cmp ax, RightClip ; then don't draw it. jg @@Done add ax, DestWidth ; If it is completely to the left dec ax ; of the left clip boundry, cmp ax, LeftClip ; then don't draw it. jl @@Done mov ax, DestWidth mov ClippedWidth, ax shl ax,1 ; Initialize the X decision var neg ax ; to be -2*DestWidth mov DecisionX, ax ; mov ax, DestHeight ; ClippedHeight is initially set to mov ClippedHeight, ax ; the requested dest size. shl ax,1 ; Initialize the Y decision var neg ax ; to be -2*DestHeight mov DecisionY, ax ; mov SourceOffset, 0 movsx eax, TopClip ; If Y is below the top mov edx, eax ; clipping boundry, then we don't sub dx, DestY ; need to clip the top, so we can js @@NoTopClip ; jump over the clipping stuff. mov DestY, ax ; This block performs clipping on the sub ClippedHeight, dx ; top of the bitmap. I have heavily movsx ecx, SourceHeight ; optimized this block to use only 4 imul ecx, edx ; 32-bit registers, so I'm not even mov eax, ecx ; gonna try to explain what it's doing. mov edx, 0 ; But I can tell you what results from movsx ebx, DestHeight ; this: The DecisionY var is updated idiv ebx ; to start at the right clipped row. movsx edx, SourceWidth ; Y is moved to the top clip imul edx, eax ; boundry. ClippedHeight is lowered since add si, dx ; we won't be drawing all the requested imul eax, ebx ; rows. SI is changed to point over sub ecx, eax ; the bitmap data that is clipped off. sub ecx, ebx ; shl ecx, 1 ; mov DecisionY, cx ; <end of top clipping block > @@NoTopClip: mov ax, DestY ; If the bitmap doesn't extend over the add ax, ClippedHeight ; bottom clipping boundry, then we dec ax ; don't need to clip the bottom, so we cmp ax, BottomClip ; can jump over the bottom clip code. jle @@NoBottomClip ; mov ax, BottomClip ; Clip off the bottom by reducing the sub ax, DestY ; ClippedHeight so that the bitmap won't inc ax ; extend over the lower clipping mov ClippedHeight, ax ; boundry. @@NoBottomClip: movsx eax, LeftClip ; If X is to the left of the mov edx, eax ; top clipping boundry, then we don't sub dx, DestX ; need to clip the left, so we can js @@NoLeftClip ; jump over the clipping stuff. mov DestX, ax ; This block performs clipping on the sub ClippedWidth, dx ; left of the bitmap. I have heavily movsx ecx, SourceWidth ; optimized this block to use only 4 imul ecx, edx ; 32-bit registers, so I'm not even mov eax, ecx ; gonna try to explain what it's doing. mov edx, 0 ; But I can tell you what results from movsx ebx, DestWidth ; this: The DecisionX var is updated idiv ebx ; to start at the right clipped column. add SourceOffset, ax ; X is moved to the left clip imul eax, ebx ; boundry. ClippedWidth is reduced since sub ecx, eax ; we won't be drawing all the requested sub ecx, ebx ; cols. SI is changed to point over shl ecx, 1 ; the bitmap data that is clipped off. mov DecisionX, cx ; <end of left clipping block > @@NoLeftClip: mov ax, DestX ; If the bitmap doesn't extend over the add ax, ClippedWidth ; right clipping boundry, then we dec ax ; don't need to clip the right, so we cmp ax, RightClip ; can jump over the right clip code. jle @@NoClipRight ; mov ax, RightClip ; Clip off the right by reducing the sub ax, DestX ; ClippedWidth so that the bitmap won't inc ax ; extend over the right clipping mov ClippedWidth, ax ; boundry. ;Calculate starting video address @@NoClipRight: mov ax, SourceWidth shl ax, 1 mov SourceWidth2, ax mov ax, SourceHeight shl ax, 1 mov SourceHeight2, ax mov ax, DestHeight shl ax, 1 mov DestHeight2, ax mov ax, DestWidth shl ax, 1 mov DestWidth2, ax mov ax, ScrnLogicalByteWidth mov ByteWidth, ax mov ax, SCREENSEG mov es, ax mov ax, DestY mov bx, ScrnLogicalByteWidth mul bx mov di, ScrnOffs add di, ax mov cx, DestX mov dx, cx shr dx, 2 add di, dx lds si, Bitmap add si, 2 add si, SourceOffset mov dx, SCINDEX ; Point the VGA Sequencer to the Map mov al, MAPMASK ; Mask register, so that we only need out dx, al ; to send out 1 byte per column. inc dx ; Move to the Sequencer's Data register. and cx, 3 ; Calculate the starting plane. This is mov al, 11h ; just: shl al, cl ; Plane = (11h << (X AND 3)) mov Plane, al out dx, al ; Select the first plane. @@RowLoop: push si ; Save the starting source index push di ; Save the starting dest index mov cx, ClippedHeight mov bx, DecisionY mov dx, ByteWidth mov al, ds:[si] @@ColumnLoop: mov es:[di], al add di, dx dec cx jz @@DoneWithCol add bx, SourceHeight2 js @@ColumnLoop @@IncSourceRow: add si, SourceWidth sub bx, DestHeight2 jns @@IncSourceRow mov al, ds:[si] jmp @@ColumnLoop @@DoneWithCol: pop di pop si rol Plane, 1 adc di, 0 mov dx, SCINDEX inc dx mov al, Plane out dx, al mov ax, SourceWidth2 add DecisionX, ax js @@NextCol @@IncSourceCol: inc si mov ax, DestWidth2 sub DecisionX, ax jns @@IncSourceCol @@NextCol: dec ClippedWidth ; If we're not at last column jnz @@RowLoop ; then do another column @@Done: pop ds shr LeftClip, 2 shr RightClip, 2 ret ; We're done! xscale ENDP xmaskedscale PROC FAR DestX:WORD, DestY:WORD, DestWidth:WORD, DestHeight:WORD,\ ScrnOffs : WORD, Bitmap:DWord LOCAL DecisionX:WORD, DecisionY:WORD, ClippedWidth:WORD, ClippedHeight:WORD,\ SourceWidth:WORD, SourceHeight:WORD, SourceOffset : Word,\ SourceWidth2 : Word, SourceHeight2 : word, ByteWidth : word,\ Plane : BYTE, DestWidth2 : word, DestHeight2 : word push ds push ds lds si, Bitmap xor ah, ah lodsb mov SourceWidth, ax lodsb mov SourceHeight, ax pop ds shl LeftClip, 2 shl RightClip, 2 cmp DestWidth, 2 ; If destination width is less than 2 jl @@Done ; then don't draw it. cmp DestHeight, 2 ; If destination height is less than 2 jl @@Done ; then don't draw it. mov ax, DestY ; If it is completely below the cmp ax, BottomClip ; lower clip bondry, jg @@Done ; then don't draw it. add ax, DestHeight ; If it is above clip boundries dec ax ; then don't draw it. cmp ax, TopClip jl @@Done mov ax, DestX ; If it is to the right of the cmp ax, RightClip ; then don't draw it. jg @@Done add ax, DestWidth ; If it is completely to the left dec ax ; of the left clip boundry, cmp ax, LeftClip ; then don't draw it. jl @@Done mov ax, DestWidth mov ClippedWidth, ax shl ax,1 ; Initialize the X decision var neg ax ; to be -2*DestWidth mov DecisionX, ax ; mov ax, DestHeight ; ClippedHeight is initially set to mov ClippedHeight, ax ; the requested dest size. shl ax,1 ; Initialize the Y decision var neg ax ; to be -2*DestHeight mov DecisionY, ax ; mov SourceOffset, 0 movsx eax, TopClip ; If Y is below the top mov edx, eax ; clipping boundry, then we don't sub dx, DestY ; need to clip the top, so we can js @@NoTopClip ; jump over the clipping stuff. mov DestY, ax ; This block performs clipping on the sub ClippedHeight, dx ; top of the bitmap. I have heavily movsx ecx, SourceHeight ; optimized this block to use only 4 imul ecx, edx ; 32-bit registers, so I'm not even mov eax, ecx ; gonna try to explain what it's doing. mov edx, 0 ; But I can tell you what results from movsx ebx, DestHeight ; this: The DecisionY var is updated idiv ebx ; to start at the right clipped row. movsx edx, SourceWidth ; Y is moved to the top clip imul edx, eax ; boundry. ClippedHeight is lowered since add si, dx ; we won't be drawing all the requested imul eax, ebx ; rows. SI is changed to point over sub ecx, eax ; the bitmap data that is clipped off. sub ecx, ebx ; shl ecx, 1 ; mov DecisionY, cx ; <end of top clipping block > @@NoTopClip: mov ax, DestY ; If the bitmap doesn't extend over the add ax, ClippedHeight ; bottom clipping boundry, then we dec ax ; don't need to clip the bottom, so we cmp ax, BottomClip ; can jump over the bottom clip code. jle @@NoBottomClip ; mov ax, BottomClip ; Clip off the bottom by reducing the sub ax, DestY ; ClippedHeight so that the bitmap won't inc ax ; extend over the lower clipping mov ClippedHeight, ax ; boundry. @@NoBottomClip: movsx eax, LeftClip ; If X is to the left of the mov edx, eax ; top clipping boundry, then we don't sub dx, DestX ; need to clip the left, so we can js @@NoLeftClip ; jump over the clipping stuff. mov DestX, ax ; This block performs clipping on the sub ClippedWidth, dx ; left of the bitmap. I have heavily movsx ecx, SourceWidth ; optimized this block to use only 4 imul ecx, edx ; 32-bit registers, so I'm not even mov eax, ecx ; gonna try to explain what it's doing. mov edx, 0 ; But I can tell you what results from movsx ebx, DestWidth ; this: The DecisionX var is updated idiv ebx ; to start at the right clipped column. add SourceOffset, ax ; X is moved to the left clip imul eax, ebx ; boundry. ClippedWidth is reduced since sub ecx, eax ; we won't be drawing all the requested sub ecx, ebx ; cols. SI is changed to point over shl ecx, 1 ; the bitmap data that is clipped off. mov DecisionX, cx ; <end of left clipping block > @@NoLeftClip: mov ax, DestX ; If the bitmap doesn't extend over the add ax, ClippedWidth ; right clipping boundry, then we dec ax ; don't need to clip the right, so we cmp ax, RightClip ; can jump over the right clip code. jle @@NoClipRight ; mov ax, RightClip ; Clip off the right by reducing the sub ax, DestX ; ClippedWidth so that the bitmap won't inc ax ; extend over the right clipping mov ClippedWidth, ax ; boundry. ;Calculate starting video address @@NoClipRight: mov ax, SourceWidth shl ax, 1 mov SourceWidth2, ax mov ax, SourceHeight shl ax, 1 mov SourceHeight2, ax mov ax, DestHeight shl ax, 1 mov DestHeight2, ax mov ax, DestWidth shl ax, 1 mov DestWidth2, ax mov ax, ScrnLogicalByteWidth mov ByteWidth, ax mov ax, SCREENSEG mov es, ax mov ax, DestY mov bx, ScrnLogicalByteWidth mul bx mov di, ScrnOffs add di, ax mov cx, DestX mov dx, cx shr dx, 2 add di, dx lds si, Bitmap add si, 2 add si, SourceOffset mov dx, SCINDEX ; Point the VGA Sequencer to the Map mov al, MAPMASK ; Mask register, so that we only need out dx, al ; to send out 1 byte per column. inc dx ; Move to the Sequencer's Data register. and cx, 3 ; Calculate the starting plane. This is mov al, 11h ; just: shl al, cl ; Plane = (11h << (X AND 3)) mov Plane, al out dx, al ; Select the first plane. @@RowLoop: push si ; Save the starting source index push di ; Save the starting dest index mov cx, ClippedHeight mov bx, DecisionY mov dx, ByteWidth mov al, ds:[si] @@ColumnLoop: or al, al jz @@DontDraw mov es:[di], al @@DontDraw: add di, dx dec cx jz @@DoneWithCol add bx, SourceHeight2 js @@ColumnLoop @@IncSourceRow: add si, SourceWidth sub bx, DestHeight2 jns @@IncSourceRow mov al, ds:[si] jmp @@ColumnLoop @@DoneWithCol: pop di pop si rol Plane, 1 adc di, 0 mov dx, SCINDEX inc dx mov al, Plane out dx, al mov ax, SourceWidth2 add DecisionX, ax js @@NextCol @@IncSourceCol: inc si mov ax, DestWidth2 sub DecisionX, ax jns @@IncSourceCol @@NextCol: dec ClippedWidth ; If we're not at last column jnz @@RowLoop ; then do another column @@Done: pop ds shr LeftClip, 2 shr RightClip, 2 ret ; We're done! xmaskedscale ENDP end